package com.zjsru.plan2024.oneday;

import java.util.HashSet;
import java.util.Set;

/**
 * @Author: cookLee
 * @Date: 2024-01-17
 * 最大字符串配对数目
 */
public class MaximumNumberOfStringPairs {
    /**
     * 主
     * \
     * 输入：words = ["cd","ac","dc","ca","zz"]
     * 输出：2
     * 解释：在此示例中，我们可以通过以下方式匹配 2 对字符串：
     * - 我们将第 0 个字符串与第 2 个字符串匹配，因为 word[0] 的反转字符串是 "dc" 并且等于 words[2]。
     * - 我们将第 1 个字符串与第 3 个字符串匹配，因为 word[1] 的反转字符串是 "ca" 并且等于 words[3]。
     * 可以证明最多匹配数目是 2
     * \
     * 输入：words = ["ab","ba","cc"]
     * 输出：1
     * 解释：在此示例中，我们可以通过以下方式匹配 1 对字符串：
     * - 我们将第 0 个字符串与第 1 个字符串匹配，因为 words[1] 的反转字符串 "ab" 与 words[0] 相等。
     * 可以证明最多匹配数目是 1 。
     * \
     * @param args args
     */
    public static void main(String[] args) {
        MaximumNumberOfStringPairs maximumNumberOfStringPairs = new MaximumNumberOfStringPairs();
        String[] words = new String[]{"cd","ac","dc","ca","zz"};
        System.out.println(maximumNumberOfStringPairs.maximumNumberOfStringPairs(words));
    }


    /**
     * 字符串对最大数量
     *
     * @param words 字词
     * @return int
     */
    public int maximumNumberOfStringPairs(String[] words) {
        int ans  = 0;
        for (int i = 0; i < words.length; i++) {
            String originWord = words[i];
            for (int j = i + 1; j < words.length; j++) {
                if(originWord.equals(this.helper(words[j]))){
                    ans ++;
                }
            }
        }
        return ans;
    }

    /**
     * 倒转字母助手类
     *
     * @param originWord 原词
     * @return {@link String}
     */
    private String helper(String originWord) {
        StringBuilder sb = new StringBuilder();
        for (int i = originWord.length() - 1; i >= 0 ; i--) {
            sb.append(originWord.charAt(i));
        }
        return sb.toString();
    }

    /**
     * 字符串对最大数量2
     * 哈希表
     * @param words 字词
     * @return int
     */
    public int maximumNumberOfStringPairs2(String[] words) {
        int ans = 0;
        Set<Integer> set = new HashSet<>();
        for (String word : words) {
            //按照数字将每个字符串定义为唯一
            Integer ascii = word.charAt(0) * 100 + word.charAt(1);
            if (set.contains(ascii)) {
                ans++;
            }
            //存入反转位数后的数字
            set.add(word.charAt(1) * 100 + word.charAt(0));
        }
        return ans;
    }
}
